.TH std::experimental::ranges::tagged 3 "2024.06.10" "http://cppreference.com" "C++ Standard Libary"
.SH NAME
std::experimental::ranges::tagged \- std::experimental::ranges::tagged

.SH Synopsis
   Defined in header <experimental/ranges/utility>
   template< class Base, TagSpecifier... Tags >

       requires sizeof...(Tags) <= std::tuple_size<Base>::value  (ranges TS)

   struct tagged;

   The class template tagged augments a tuple-like class type Base, which it publicly
   derives from, with a set of named accessors specified by the tag specifiers Tags....
   The tags are applied in order: the i-th tag specifier in Tags... correspond to the
   i-th element of the tuple.

   The tag specifiers in Tags... shall be unique. Otherwise, the behavior is undefined.

   It is not possible to delete an instance of tagged through a pointer to any base
   other than Base.

.SH Member functions

   constructor   construct a tagged object
                 \fI(public member function)\fP
   operator=     assigns a tagged object
                 \fI(public member function)\fP
   swap          swaps the contents of two tagged objects
                 \fI(public member function)\fP

     Named element accessors

   For the N-th tag specifier in Tags... whose corresponding element name is name,
   tagged provides accessors named name as follows:

 constexpr decltype(auto) name() &       { return std::get<N>(*this); }
 constexpr decltype(auto) name() const & { return std::get<N>(*this); }
 constexpr decltype(auto) name() &&      { return std::get<N>(std::move(*this)); }

.SH Non-member functions

   ranges::swap(ranges::tagged) specializes swap for tagged objects
                                \fI(function)\fP

   Tuple-like access

                                                         obtains the size of a tagged
   std::tuple_size<std::experimental::ranges::tagged>    (class template
                                                         specialization)
                                                         obtains the types of the
   std::tuple_element<std::experimental::ranges::tagged> elements of a tagged
                                                         (class template
                                                         specialization)

.SH See also

   TagSpecifier      specifies that a type is a tag specifier
                     (concept)
   tagged_pair       alias template for a tagged std::pair
                     (alias template)
   make_tagged_pair  convenience function for creating a tagged_pair
                     \fI(function template)\fP
   tagged_tuple      alias template for a tagged std::tuple
                     (alias template)
   make_tagged_tuple convenience function for creating a tagged_tuple
                     \fI(function template)\fP
   in
   in1
   in2
   out
   out1              tag specifiers for use with ranges::tagged
   out2              \fI(class)\fP
   fun
   min
   max
   begin
   end
